const MultiModel = require('../../../framework/database/multi_model.js');
const BaseProjectModel = require('./base_project_model.js');
const util = require('../../../framework/helpers/util.js');
const timeUtil = require('../../../framework/helpers/time_util.js');
const dataUtil = require('../../../framework/helpers/data_util.js');
const config = require('../../../config/config.js');

class ProjectModel extends MultiModel {

	constructor() {
		super();

		// 直接设置collection，不使用setModel
		this._collection = BaseProjectModel.C('oa_project');
	}

	/**
	 * 获取集合名称
	 */
	static getCollectionName() {
		return BaseProjectModel.C('oa_project');
	}

	/**
	 * 获取项目列表
	 * @param {Object} param0 查询参数
	 * @returns 项目列表
	 */
	static async getProjectList({ search, sortType, sortVal, page, size, status }) {
		let query = {};
		let orderBy = {
			'createTime': 'desc',  // 默认按创建时间倒序
			'_id': 'desc'         // 第二排序键为ID
		};

		// 打印传入的参数
		console.log('[getProjectList] 传入参数:', {
			search, sortType, sortVal, page, size, status
		});

		// 状态条件
		if (status) {
			query.status = status;
		}

		// 搜索条件
		if (search) {
			query['$or'] = [
				{
					name: {
						$regex: search,
						$options: 'i'
					}
				},
				{
					leader: {
						$regex: search,
						$options: 'i'
					}
				},
				{
					department: {
						$regex: search,
						$options: 'i'
					}
				}
			];
		}

		// 根据排序类型设置排序
		if (sortType) {
			switch (sortType) {
				case 'recent':
					orderBy = { 
						createTime: 'desc',
						_id: 'desc'
					};
					break;
				case 'urgent':
					orderBy = { 
						priority: 'desc', 
						deadline: 'asc',
						_id: 'desc'
					};
					break;
				case 'normal':
				default:
					orderBy = { 
						createTime: 'desc',
						_id: 'desc'
					};
			}
		}

		try {
			console.log(`[getProjectList] 开始查询集合: ${this.getCollectionName()}，条件:`, JSON.stringify(query));
			console.log(`[getProjectList] 排序条件:`, JSON.stringify(orderBy));

			// 获取总数
			let total = await this.count(query);
			console.log(`[getProjectList] 查询结果总数: ${total}`);
			
			if (total === 0) {
				console.log(`[getProjectList] 没有找到项目数据`);
				return {
					total: 0,
					list: []
				};
			}
			
			// 获取列表数据
			let list = await this.getList(query, '*', orderBy, page, size);
			console.log(`[getProjectList] 获取列表成功，列表大小: ${list ? list.length : 0}`);
			
			// 确保list是一个数组
			if (!Array.isArray(list.list)) {
				list.list = [];
			}
			
			// 过滤掉非对象数据
			list.list = list.list.filter(item => typeof item === 'object' && item !== null);
			
			console.log('[getProjectList] 过滤后的数据列表大小:', list.list.length);

			// 返回结果
			let result = {
				total,
				list: list.list,
				page,
				size,
				// 添加统计数据
				statistics: {
					total: total,
					pending: await this.count({ status: 'planning' }),
					ongoing: await this.count({ status: 'ongoing' }),
					completed: await this.count({ status: 'completed' }),
					suspended: await this.count({ status: 'suspended' })
				}
			};

			console.log(`[getProjectList] 返回结果:`, JSON.stringify(result));
			return result;

		} catch (err) {
			console.error('[getProjectList] 获取项目列表失败:', err);
			throw err;
		}
	}

	/**
	 * 获取项目详情
	 * @param {string} id 项目ID
	 * @returns 项目详情
	 */
	static async getProjectDetail(id) {
		return await this.getOne(id);
	}

	/**
	 * 获取单个项目
	 * @param {Object} where 查询条件
	 * @returns 项目详情
	 */
	static async getProject(where) {
		return await this.getOne(where);
	}

	/**
	 * 插入项目
	 * @param {Object} data 项目数据
	 * @returns 插入结果
	 */
	static async insertProject(data) {
		// 使用毫秒级时间戳
		const now = Date.now();
		data.createTime = now;
		data.updateTime = now;

		// 确保日期字段也是毫秒级时间戳
		if (data.startDate && typeof data.startDate === 'number') {
			// 如果是秒级时间戳，转换为毫秒级
			if (data.startDate < 10000000000) {
				data.startDate *= 1000;
			}
		}
		if (data.deadline && typeof data.deadline === 'number') {
			// 如果是秒级时间戳，转换为毫秒级
			if (data.deadline < 10000000000) {
				data.deadline *= 1000;
			}
		}

		// 尝试过滤掉非结构化字段，避免脏数据错误
		try {
			const safeData = {};
			
			for (let key in data) {
				// 只保留DB_STRUCTURE中定义的字段
				if (this.DB_STRUCTURE.hasOwnProperty(key)) {
					safeData[key] = data[key];
				}
			}
			
			console.log('[insertProject] 过滤后要插入的安全数据:', safeData);
			return await this.insert(safeData);
		} catch (err) {
			console.error('[insertProject] 插入数据失败:', err);
			throw err;
		}
	}

	/**
	 * 更新项目
	 * @param {string} id 项目ID
	 * @param {Object} data 项目数据
	 * @returns 更新结果
	 */
	static async updateProject(id, data) {
		data.updateTime = timeUtil.time(); // 更新时间
		
		let where = {
			_id: id
		}
		return await this.edit(where, data);
	}

	/**
	 * 删除项目
	 * @param {string} id 项目ID
	 */
	static async deleteProject(id) {
		return await this.del(id);
	}

	/**
	 * 自定义统计
	 * @param {string} key 统计字段
	 * @param {Object} where 查询条件
	 * @returns 统计结果
	 */
	static async groupCount(key, where = {}) {
		return await this.groupSum(key, where);
	}

	/**
	 * 获取所有项目数量
	 */
	static async getAllProjectCount() {
		return await this.count({});
	}

	/**
	 * 获取正在进行的项目数量
	 */
	static async getOngoingProjectCount() {
		return await this.count({
			status: 'ongoing'
		});
	}

	/**
	 * 获取已完成的项目数量
	 */
	static async getCompletedProjectCount() {
		return await this.count({
			status: 'completed'
		});
	}

	/**
	 * 获取已暂停的项目数量
	 */
	static async getSuspendedProjectCount() {
		return await this.count({
			status: 'suspended'
		});
	}

	/**
	 * 自增项目的某个字段
	 */
	static async increment(where, field, val = 1) {
		return await this.inc(where, field, val);
	}

	/**
	 * 自减项目的某个字段
	 */
	static async decrement(where, field, val = 1) {
		return await this.dec(where, field, val);
	}
}

// 静态数据结构
ProjectModel.DB_STRUCTURE = {
	_pid: 'string|true',
	USER_ID: 'string|false', // 所属用户ID
	projectNo: 'string|false|comment=项目编号',
	NO_ID: 'string|false', // 添加框架所需的ID字段
	NO_ADD_TIME: 'int|false', // 添加时间
	NO_EDIT_TIME: 'int|false', // 修改时间
	NO_ADD_IP: 'string|false', // 添加IP
	NO_EDIT_IP: 'string|false', // 修改IP
	
	name: 'string|true|comment=项目名称',
	leader: 'string|true|comment=项目负责人',
	department: 'string|true|comment=所属部门',
	startDate: 'int|true|comment=开始日期',
	deadline: 'int|true|comment=截止日期',
	priority: 'string|true|comment=优先级',
	status: 'string|true|comment=状态',
	description: 'string|false|comment=项目描述',
	
	// 应用类型相关
	applicationType: 'string|false|comment=应用类型',
	
	// 工作环境和认证
	workTemp: 'string|false|comment=工作环境温度',
	certification: 'string|false|comment=认证要求',
	
	// 电机参数
	lowPower: 'string|false|comment=低功耗要求',
	startupTime: 'string|false|comment=启动时间要求',
	conformalCoating: 'string|false|comment=三防漆要求',
	ratedVoltage: 'string|false|comment=额定电压',
	maxPower: 'string|false|comment=最大功率',
	maxSpeed: 'string|false|comment=最高转速',
	polePairs: 'string|false|comment=极对数',
	hasHall: 'string|false|comment=霍尔传感器',
	hasFG: 'string|false|comment=频率发生器',
	controlMode: 'string|false|comment=控制模式',
	controlAlgorithm: 'string|false|comment=控制算法',
	rotation: 'string|false|comment=旋转方向',
	hasBrake: 'string|false|comment=刹车功能',
	
	// 保护参数
	stallProtection: 'string|false|comment=失速保护',
	overvoltageProtection: 'string|false|comment=过压保护',
	undervoltageProtection: 'string|false|comment=欠压保护',
	temperatureProtection: 'string|false|comment=温度保护',
	overcurrentProtection: 'string|false|comment=过流保护',
	currentLimitProtection: 'string|false|comment=限流保护',
	blockageProtection: 'string|false|comment=堵转保护',
	phaseProtection: 'string|false|comment=缺相保护',
	
	customerName: 'string|false|comment=客户名称',
	createTime: 'int|true',
	updateTime: 'int|true',
};

module.exports = ProjectModel; 